home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_deque.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  24KB  |  690 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. from collections import deque
  5. import unittest
  6. from test import test_support
  7. from weakref import proxy
  8. import copy
  9. import cPickle as pickle
  10. from cStringIO import StringIO
  11. import random
  12. import os
  13. BIG = 100000
  14.  
  15. def fail():
  16.     raise SyntaxError
  17.     yield 1
  18.  
  19.  
  20. class TestBasic(unittest.TestCase):
  21.     
  22.     def test_basics(self):
  23.         d = deque(xrange(100))
  24.         d.__init__(xrange(100, 200))
  25.         for i in xrange(200, 400):
  26.             d.append(i)
  27.         
  28.         for i in reversed(xrange(-200, 0)):
  29.             d.appendleft(i)
  30.         
  31.         self.assertEqual(list(d), range(-200, 400))
  32.         self.assertEqual(len(d), 600)
  33.         left = [ d.popleft() for i in xrange(250) ]
  34.         self.assertEqual(left, range(-200, 50))
  35.         self.assertEqual(list(d), range(50, 400))
  36.         right = [ d.pop() for i in xrange(250) ]
  37.         right.reverse()
  38.         self.assertEqual(right, range(150, 400))
  39.         self.assertEqual(list(d), range(50, 150))
  40.  
  41.     
  42.     def test_comparisons(self):
  43.         d = deque('xabc')
  44.         d.popleft()
  45.         for e in [
  46.             d,
  47.             deque('abc'),
  48.             deque('ab'),
  49.             deque(),
  50.             list(d)]:
  51.             if type(d) == type(e):
  52.                 pass
  53.             self.assertEqual(d == e, list(d) == list(e))
  54.             if type(d) == type(e):
  55.                 pass
  56.             self.assertEqual(d != e, not (list(d) == list(e)))
  57.         
  58.         args = map(deque, ('', 'a', 'b', 'ab', 'ba', 'abc', 'xba', 'xabc', 'cba'))
  59.         for x in args:
  60.             for y in args:
  61.                 self.assertEqual(x == y, list(x) == list(y), (x, y))
  62.                 self.assertEqual(x != y, list(x) != list(y), (x, y))
  63.                 self.assertEqual(x < y, list(x) < list(y), (x, y))
  64.                 self.assertEqual(x <= y, list(x) <= list(y), (x, y))
  65.                 self.assertEqual(x > y, list(x) > list(y), (x, y))
  66.                 self.assertEqual(x >= y, list(x) >= list(y), (x, y))
  67.                 self.assertEqual(cmp(x, y), cmp(list(x), list(y)), (x, y))
  68.             
  69.         
  70.  
  71.     
  72.     def test_extend(self):
  73.         d = deque('a')
  74.         self.assertRaises(TypeError, d.extend, 1)
  75.         d.extend('bcd')
  76.         self.assertEqual(list(d), list('abcd'))
  77.  
  78.     
  79.     def test_extendleft(self):
  80.         d = deque('a')
  81.         self.assertRaises(TypeError, d.extendleft, 1)
  82.         d.extendleft('bcd')
  83.         self.assertEqual(list(d), list(reversed('abcd')))
  84.         d = deque()
  85.         d.extendleft(range(1000))
  86.         self.assertEqual(list(d), list(reversed(range(1000))))
  87.         self.assertRaises(SyntaxError, d.extendleft, fail())
  88.  
  89.     
  90.     def test_getitem(self):
  91.         n = 200
  92.         d = deque(xrange(n))
  93.         l = range(n)
  94.         for i in xrange(n):
  95.             d.popleft()
  96.             l.pop(0)
  97.             if random.random() < 0.5:
  98.                 d.append(i)
  99.                 l.append(i)
  100.             
  101.             for j in xrange(1 - len(l), len(l)):
  102.                 pass
  103.             
  104.         
  105.         d = deque('superman')
  106.         self.assertEqual(d[0], 's')
  107.         self.assertEqual(d[-1], 'n')
  108.         d = deque()
  109.         self.assertRaises(IndexError, d.__getitem__, 0)
  110.         self.assertRaises(IndexError, d.__getitem__, -1)
  111.  
  112.     
  113.     def test_setitem(self):
  114.         n = 200
  115.         d = deque(xrange(n))
  116.         for i in xrange(n):
  117.             d[i] = 10 * i
  118.         
  119.         []([], [ 10 * i for i in xrange(n) ])
  120.         l = list(d)
  121.         for i in xrange(1 - n, 0, -1):
  122.             d[i] = 7 * i
  123.             l[i] = 7 * i
  124.         
  125.         self.assertEqual(list(d), l)
  126.  
  127.     
  128.     def test_delitem(self):
  129.         n = 500
  130.         d = deque(xrange(n))
  131.         self.assertRaises(IndexError, d.__delitem__, -n - 1)
  132.         self.assertRaises(IndexError, d.__delitem__, n)
  133.         for i in xrange(n):
  134.             self.assertEqual(len(d), n - i)
  135.             j = random.randrange(-len(d), len(d))
  136.             val = d[j]
  137.             self.assert_(val in d)
  138.             del d[j]
  139.             self.assert_(val not in d)
  140.         
  141.         self.assertEqual(len(d), 0)
  142.  
  143.     
  144.     def test_rotate(self):
  145.         s = tuple('abcde')
  146.         n = len(s)
  147.         d = deque(s)
  148.         d.rotate(1)
  149.         self.assertEqual(''.join(d), 'eabcd')
  150.         d = deque(s)
  151.         d.rotate(-1)
  152.         self.assertEqual(''.join(d), 'bcdea')
  153.         d.rotate()
  154.         self.assertEqual(tuple(d), s)
  155.         for i in xrange(n * 3):
  156.             d = deque(s)
  157.             e = deque(d)
  158.             d.rotate(i)
  159.             for j in xrange(i):
  160.                 e.rotate(1)
  161.             
  162.             self.assertEqual(tuple(d), tuple(e))
  163.             d.rotate(-i)
  164.             self.assertEqual(tuple(d), s)
  165.             e.rotate(n - i)
  166.             self.assertEqual(tuple(e), s)
  167.         
  168.         for i in xrange(n * 3):
  169.             d = deque(s)
  170.             e = deque(d)
  171.             d.rotate(-i)
  172.             for j in xrange(i):
  173.                 e.rotate(-1)
  174.             
  175.             self.assertEqual(tuple(d), tuple(e))
  176.             d.rotate(i)
  177.             self.assertEqual(tuple(d), s)
  178.             e.rotate(i - n)
  179.             self.assertEqual(tuple(e), s)
  180.         
  181.         d = deque(s)
  182.         e = deque(s)
  183.         e.rotate(BIG + 17)
  184.         dr = d.rotate
  185.         for i in xrange(BIG + 17):
  186.             dr()
  187.         
  188.         self.assertEqual(tuple(d), tuple(e))
  189.         self.assertRaises(TypeError, d.rotate, 'x')
  190.         self.assertRaises(TypeError, d.rotate, 1, 10)
  191.         d = deque()
  192.         d.rotate()
  193.         self.assertEqual(d, deque())
  194.  
  195.     
  196.     def test_len(self):
  197.         d = deque('ab')
  198.         self.assertEqual(len(d), 2)
  199.         d.popleft()
  200.         self.assertEqual(len(d), 1)
  201.         d.pop()
  202.         self.assertEqual(len(d), 0)
  203.         self.assertRaises(IndexError, d.pop)
  204.         self.assertEqual(len(d), 0)
  205.         d.append('c')
  206.         self.assertEqual(len(d), 1)
  207.         d.appendleft('d')
  208.         self.assertEqual(len(d), 2)
  209.         d.clear()
  210.         self.assertEqual(len(d), 0)
  211.  
  212.     
  213.     def test_underflow(self):
  214.         d = deque()
  215.         self.assertRaises(IndexError, d.pop)
  216.         self.assertRaises(IndexError, d.popleft)
  217.  
  218.     
  219.     def test_clear(self):
  220.         d = deque(xrange(100))
  221.         self.assertEqual(len(d), 100)
  222.         d.clear()
  223.         self.assertEqual(len(d), 0)
  224.         self.assertEqual(list(d), [])
  225.         d.clear()
  226.         self.assertEqual(list(d), [])
  227.  
  228.     
  229.     def test_repr(self):
  230.         d = deque(xrange(200))
  231.         e = eval(repr(d))
  232.         self.assertEqual(list(d), list(e))
  233.         d.append(d)
  234.         self.assert_('...' in repr(d))
  235.  
  236.     
  237.     def test_print(self):
  238.         d = deque(xrange(200))
  239.         d.append(d)
  240.         
  241.         try:
  242.             fo = open(test_support.TESTFN, 'wb')
  243.             print >>fo, d,
  244.             fo.close()
  245.             fo = open(test_support.TESTFN, 'rb')
  246.             self.assertEqual(fo.read(), repr(d))
  247.         finally:
  248.             fo.close()
  249.             os.remove(test_support.TESTFN)
  250.  
  251.  
  252.     
  253.     def test_init(self):
  254.         self.assertRaises(TypeError, deque, 'abc', 2)
  255.         self.assertRaises(TypeError, deque, 1)
  256.  
  257.     
  258.     def test_hash(self):
  259.         self.assertRaises(TypeError, hash, deque('abc'))
  260.  
  261.     
  262.     def test_long_steadystate_queue_popleft(self):
  263.         for size in (0, 1, 2, 100, 1000):
  264.             d = deque(xrange(size))
  265.             append = d.append
  266.             pop = d.popleft
  267.             for i in xrange(size, BIG):
  268.                 append(i)
  269.                 x = pop()
  270.                 if x != i - size:
  271.                     self.assertEqual(x, i - size)
  272.                     continue
  273.             
  274.             self.assertEqual(list(d), range(BIG - size, BIG))
  275.         
  276.  
  277.     
  278.     def test_long_steadystate_queue_popright(self):
  279.         for size in (0, 1, 2, 100, 1000):
  280.             d = deque(reversed(xrange(size)))
  281.             append = d.appendleft
  282.             pop = d.pop
  283.             for i in xrange(size, BIG):
  284.                 append(i)
  285.                 x = pop()
  286.                 if x != i - size:
  287.                     self.assertEqual(x, i - size)
  288.                     continue
  289.             
  290.             self.assertEqual(list(reversed(list(d))), range(BIG - size, BIG))
  291.         
  292.  
  293.     
  294.     def test_big_queue_popleft(self):
  295.         d = deque()
  296.         append = d.append
  297.         pop = d.popleft
  298.         for i in xrange(BIG):
  299.             append(i)
  300.         
  301.         for i in xrange(BIG):
  302.             x = pop()
  303.             if x != i:
  304.                 self.assertEqual(x, i)
  305.                 continue
  306.         
  307.  
  308.     
  309.     def test_big_queue_popright(self):
  310.         d = deque()
  311.         append = d.appendleft
  312.         pop = d.pop
  313.         for i in xrange(BIG):
  314.             append(i)
  315.         
  316.         for i in xrange(BIG):
  317.             x = pop()
  318.             if x != i:
  319.                 self.assertEqual(x, i)
  320.                 continue
  321.         
  322.  
  323.     
  324.     def test_big_stack_right(self):
  325.         d = deque()
  326.         append = d.append
  327.         pop = d.pop
  328.         for i in xrange(BIG):
  329.             append(i)
  330.         
  331.         for i in reversed(xrange(BIG)):
  332.             x = pop()
  333.             if x != i:
  334.                 self.assertEqual(x, i)
  335.                 continue
  336.         
  337.         self.assertEqual(len(d), 0)
  338.  
  339.     
  340.     def test_big_stack_left(self):
  341.         d = deque()
  342.         append = d.appendleft
  343.         pop = d.popleft
  344.         for i in xrange(BIG):
  345.             append(i)
  346.         
  347.         for i in reversed(xrange(BIG)):
  348.             x = pop()
  349.             if x != i:
  350.                 self.assertEqual(x, i)
  351.                 continue
  352.         
  353.         self.assertEqual(len(d), 0)
  354.  
  355.     
  356.     def test_roundtrip_iter_init(self):
  357.         d = deque(xrange(200))
  358.         e = deque(d)
  359.         self.assertNotEqual(id(d), id(e))
  360.         self.assertEqual(list(d), list(e))
  361.  
  362.     
  363.     def test_pickle(self):
  364.         d = deque(xrange(200))
  365.         for i in (0, 1, 2):
  366.             s = pickle.dumps(d, i)
  367.             e = pickle.loads(s)
  368.             self.assertNotEqual(id(d), id(e))
  369.             self.assertEqual(list(d), list(e))
  370.         
  371.  
  372.     
  373.     def test_pickle_recursive(self):
  374.         d = deque('abc')
  375.         d.append(d)
  376.         for i in (0, 1, 2):
  377.             e = pickle.loads(pickle.dumps(d, i))
  378.             self.assertNotEqual(id(d), id(e))
  379.             self.assertEqual(id(e), id(e[-1]))
  380.         
  381.  
  382.     
  383.     def test_deepcopy(self):
  384.         mut = [
  385.             10]
  386.         d = deque([
  387.             mut])
  388.         e = copy.deepcopy(d)
  389.         self.assertEqual(list(d), list(e))
  390.         mut[0] = 11
  391.         self.assertNotEqual(id(d), id(e))
  392.         self.assertNotEqual(list(d), list(e))
  393.  
  394.     
  395.     def test_copy(self):
  396.         mut = [
  397.             10]
  398.         d = deque([
  399.             mut])
  400.         e = copy.copy(d)
  401.         self.assertEqual(list(d), list(e))
  402.         mut[0] = 11
  403.         self.assertNotEqual(id(d), id(e))
  404.         self.assertEqual(list(d), list(e))
  405.  
  406.     
  407.     def test_reversed(self):
  408.         for s in ('abcd', xrange(2000)):
  409.             self.assertEqual(list(reversed(deque(s))), list(reversed(s)))
  410.         
  411.  
  412.     
  413.     def test_gc_doesnt_blowup(self):
  414.         import gc as gc
  415.         d = deque()
  416.         for i in xrange(100):
  417.             d.append(1)
  418.             gc.collect()
  419.         
  420.  
  421.  
  422.  
  423. def R(seqn):
  424.     '''Regular generator'''
  425.     for i in seqn:
  426.         yield i
  427.     
  428.  
  429.  
  430. class G:
  431.     '''Sequence using __getitem__'''
  432.     
  433.     def __init__(self, seqn):
  434.         self.seqn = seqn
  435.  
  436.     
  437.     def __getitem__(self, i):
  438.         return self.seqn[i]
  439.  
  440.  
  441.  
  442. class I:
  443.     '''Sequence using iterator protocol'''
  444.     
  445.     def __init__(self, seqn):
  446.         self.seqn = seqn
  447.         self.i = 0
  448.  
  449.     
  450.     def __iter__(self):
  451.         return self
  452.  
  453.     
  454.     def next(self):
  455.         if self.i >= len(self.seqn):
  456.             raise StopIteration
  457.         
  458.         v = self.seqn[self.i]
  459.         self.i += 1
  460.         return v
  461.  
  462.  
  463.  
  464. class Ig:
  465.     '''Sequence using iterator protocol defined with a generator'''
  466.     
  467.     def __init__(self, seqn):
  468.         self.seqn = seqn
  469.         self.i = 0
  470.  
  471.     
  472.     def __iter__(self):
  473.         for val in self.seqn:
  474.             yield val
  475.         
  476.  
  477.  
  478.  
  479. class X:
  480.     '''Missing __getitem__ and __iter__'''
  481.     
  482.     def __init__(self, seqn):
  483.         self.seqn = seqn
  484.         self.i = 0
  485.  
  486.     
  487.     def next(self):
  488.         if self.i >= len(self.seqn):
  489.             raise StopIteration
  490.         
  491.         v = self.seqn[self.i]
  492.         self.i += 1
  493.         return v
  494.  
  495.  
  496.  
  497. class N:
  498.     '''Iterator missing next()'''
  499.     
  500.     def __init__(self, seqn):
  501.         self.seqn = seqn
  502.         self.i = 0
  503.  
  504.     
  505.     def __iter__(self):
  506.         return self
  507.  
  508.  
  509.  
  510. class E:
  511.     '''Test propagation of exceptions'''
  512.     
  513.     def __init__(self, seqn):
  514.         self.seqn = seqn
  515.         self.i = 0
  516.  
  517.     
  518.     def __iter__(self):
  519.         return self
  520.  
  521.     
  522.     def next(self):
  523.         3 // 0
  524.  
  525.  
  526.  
  527. class S:
  528.     '''Test immediate stop'''
  529.     
  530.     def __init__(self, seqn):
  531.         pass
  532.  
  533.     
  534.     def __iter__(self):
  535.         return self
  536.  
  537.     
  538.     def next(self):
  539.         raise StopIteration
  540.  
  541.  
  542. from itertools import chain, imap
  543.  
  544. def L(seqn):
  545.     '''Test multiple tiers of iterators'''
  546.     return chain(imap((lambda x: x), R(Ig(G(seqn)))))
  547.  
  548.  
  549. class TestVariousIteratorArgs(unittest.TestCase):
  550.     
  551.     def test_constructor(self):
  552.         for s in ('123', '', range(1000), ('do', 1.2), xrange(2000, 2200, 5)):
  553.             for g in (G, I, Ig, S, L, R):
  554.                 self.assertEqual(list(deque(g(s))), list(g(s)))
  555.             
  556.             self.assertRaises(TypeError, deque, X(s))
  557.             self.assertRaises(TypeError, deque, N(s))
  558.             self.assertRaises(ZeroDivisionError, deque, E(s))
  559.         
  560.  
  561.     
  562.     def test_iter_with_altered_data(self):
  563.         d = deque('abcdefg')
  564.         it = iter(d)
  565.         d.pop()
  566.         self.assertRaises(RuntimeError, it.next)
  567.  
  568.  
  569.  
  570. class Deque(deque):
  571.     pass
  572.  
  573.  
  574. class DequeWithBadIter(deque):
  575.     
  576.     def __iter__(self):
  577.         raise TypeError
  578.  
  579.  
  580.  
  581. class TestSubclass(unittest.TestCase):
  582.     
  583.     def test_basics(self):
  584.         d = Deque(xrange(100))
  585.         d.__init__(xrange(100, 200))
  586.         for i in xrange(200, 400):
  587.             d.append(i)
  588.         
  589.         for i in reversed(xrange(-200, 0)):
  590.             d.appendleft(i)
  591.         
  592.         self.assertEqual(list(d), range(-200, 400))
  593.         self.assertEqual(len(d), 600)
  594.         left = [ d.popleft() for i in xrange(250) ]
  595.         self.assertEqual(left, range(-200, 50))
  596.         self.assertEqual(list(d), range(50, 400))
  597.         right = [ d.pop() for i in xrange(250) ]
  598.         right.reverse()
  599.         self.assertEqual(right, range(150, 400))
  600.         self.assertEqual(list(d), range(50, 150))
  601.         d.clear()
  602.         self.assertEqual(len(d), 0)
  603.  
  604.     
  605.     def test_copy_pickle(self):
  606.         d = Deque('abc')
  607.         e = d.__copy__()
  608.         self.assertEqual(type(d), type(e))
  609.         self.assertEqual(list(d), list(e))
  610.         e = Deque(d)
  611.         self.assertEqual(type(d), type(e))
  612.         self.assertEqual(list(d), list(e))
  613.         s = pickle.dumps(d)
  614.         e = pickle.loads(s)
  615.         self.assertNotEqual(id(d), id(e))
  616.         self.assertEqual(type(d), type(e))
  617.         self.assertEqual(list(d), list(e))
  618.  
  619.     
  620.     def test_pickle(self):
  621.         d = Deque('abc')
  622.         d.append(d)
  623.         e = pickle.loads(pickle.dumps(d))
  624.         self.assertNotEqual(id(d), id(e))
  625.         self.assertEqual(type(d), type(e))
  626.         dd = d.pop()
  627.         ee = e.pop()
  628.         self.assertEqual(id(e), id(ee))
  629.         self.assertEqual(d, e)
  630.         d.x = d
  631.         e = pickle.loads(pickle.dumps(d))
  632.         self.assertEqual(id(e), id(e.x))
  633.         d = DequeWithBadIter('abc')
  634.         self.assertRaises(TypeError, pickle.dumps, d)
  635.  
  636.     
  637.     def test_weakref(self):
  638.         d = deque('gallahad')
  639.         p = proxy(d)
  640.         self.assertEqual(str(p), str(d))
  641.         d = None
  642.         self.assertRaises(ReferenceError, str, p)
  643.  
  644.     
  645.     def test_strange_subclass(self):
  646.         
  647.         class X(deque):
  648.             
  649.             def __iter__(self):
  650.                 return iter([])
  651.  
  652.  
  653.         d1 = X([
  654.             1,
  655.             2,
  656.             3])
  657.         d2 = X([
  658.             4,
  659.             5,
  660.             6])
  661.         d1 == d2
  662.  
  663.  
  664. libreftest = '\nExample from the Library Reference:  Doc/lib/libcollections.tex\n\n>>> from collections import deque\n>>> d = deque(\'ghi\')                 # make a new deque with three items\n>>> for elem in d:                   # iterate over the deque\'s elements\n...     print elem.upper()\nG\nH\nI\n>>> d.append(\'j\')                    # add a new entry to the right side\n>>> d.appendleft(\'f\')                # add a new entry to the left side\n>>> d                                # show the representation of the deque\ndeque([\'f\', \'g\', \'h\', \'i\', \'j\'])\n>>> d.pop()                          # return and remove the rightmost item\n\'j\'\n>>> d.popleft()                      # return and remove the leftmost item\n\'f\'\n>>> list(d)                          # list the contents of the deque\n[\'g\', \'h\', \'i\']\n>>> d[0]                             # peek at leftmost item\n\'g\'\n>>> d[-1]                            # peek at rightmost item\n\'i\'\n>>> list(reversed(d))                # list the contents of a deque in reverse\n[\'i\', \'h\', \'g\']\n>>> \'h\' in d                         # search the deque\nTrue\n>>> d.extend(\'jkl\')                  # add multiple elements at once\n>>> d\ndeque([\'g\', \'h\', \'i\', \'j\', \'k\', \'l\'])\n>>> d.rotate(1)                      # right rotation\n>>> d\ndeque([\'l\', \'g\', \'h\', \'i\', \'j\', \'k\'])\n>>> d.rotate(-1)                     # left rotation\n>>> d\ndeque([\'g\', \'h\', \'i\', \'j\', \'k\', \'l\'])\n>>> deque(reversed(d))               # make a new deque in reverse order\ndeque([\'l\', \'k\', \'j\', \'i\', \'h\', \'g\'])\n>>> d.clear()                        # empty the deque\n>>> d.pop()                          # cannot pop from an empty deque\nTraceback (most recent call last):\n  File "<pyshell#6>", line 1, in -toplevel-\n    d.pop()\nIndexError: pop from an empty deque\n\n>>> d.extendleft(\'abc\')              # extendleft() reverses the input order\n>>> d\ndeque([\'c\', \'b\', \'a\'])\n\n\n\n>>> def delete_nth(d, n):\n...     d.rotate(-n)\n...     d.popleft()\n...     d.rotate(n)\n...\n>>> d = deque(\'abcdef\')\n>>> delete_nth(d, 2)   # remove the entry at d[2]\n>>> d\ndeque([\'a\', \'b\', \'d\', \'e\', \'f\'])\n\n\n\n>>> def roundrobin(*iterables):\n...     pending = deque(iter(i) for i in iterables)\n...     while pending:\n...         task = pending.popleft()\n...         try:\n...             yield task.next()\n...         except StopIteration:\n...             continue\n...         pending.append(task)\n...\n\n>>> for value in roundrobin(\'abc\', \'d\', \'efgh\'):\n...     print value\n...\na\nd\ne\nb\nf\nc\ng\nh\n\n\n>>> def maketree(iterable):\n...     d = deque(iterable)\n...     while len(d) > 1:\n...         pair = [d.popleft(), d.popleft()]\n...         d.append(pair)\n...     return list(d)\n...\n>>> print maketree(\'abcdefgh\')\n[[[[\'a\', \'b\'], [\'c\', \'d\']], [[\'e\', \'f\'], [\'g\', \'h\']]]]\n\n'
  665. __test__ = {
  666.     'libreftest': libreftest }
  667.  
  668. def test_main(verbose = None):
  669.     import sys as sys
  670.     test_classes = (TestBasic, TestVariousIteratorArgs, TestSubclass)
  671.     test_support.run_unittest(*test_classes)
  672.     if verbose and hasattr(sys, 'gettotalrefcount'):
  673.         import gc
  674.         counts = [
  675.             None] * 5
  676.         for i in xrange(len(counts)):
  677.             test_support.run_unittest(*test_classes)
  678.             gc.collect()
  679.             counts[i] = sys.gettotalrefcount()
  680.         
  681.         print counts
  682.     
  683.     test_deque = test_deque
  684.     import test
  685.     test_support.run_doctest(test_deque, verbose)
  686.  
  687. if __name__ == '__main__':
  688.     test_main(verbose = True)
  689.  
  690.